//package cc.magicjson.example.demo.stw;
//
//import jdk.internal.misc.Unsafe;
//import java.lang.reflect.Field;
//import java.util.concurrent.atomic.AtomicInteger;
//
//public class STWDemo {
//    // 获取Unsafe实例，用于直接内存操作
//    private static final Unsafe UNSAFE;
//    // 线程状态字段在JavaThread对象中的偏移量
//    private static final long STATE_OFFSET;
//
//    static {
//        try {
//            // 通过反射获取Unsafe实例
//            Field f = Unsafe.class.getDeclaredField("theUnsafe");
//            f.setAccessible(true);
//            UNSAFE = (Unsafe) f.get(null);
//            // 获取_thread_state字段的偏移量
//            STATE_OFFSET = UNSAFE.objectFieldOffset(JavaThread.class.getDeclaredField("_thread_state"));
//        } catch (Exception e) {
//            throw new RuntimeException(e);
//        }
//    }
//
//    // 定义线程状态常量，模拟JVM中的线程状态
//    private static final int _thread_in_Java = 2;  // 线程在执行Java代码
//    private static final int _thread_in_vm = 4;    // 线程在VM中
//    private static final int _thread_blocked = 6;  // 线程被阻塞
//
//    // 自定义Thread类，模拟JVM中的JavaThread
//    static class JavaThread extends Thread {
//        private volatile int _thread_state = _thread_in_Java;
//
//        JavaThread(Runnable target) {
//            super(target);
//        }
//
//        // 设置线程状态，使用Unsafe直接写入内存
//        void set_thread_state(int state) {
//            UNSAFE.putIntVolatile(this, STATE_OFFSET, state);
//        }
//
//        // 获取线程状态，使用Unsafe直接读取内存
//        int get_thread_state() {
//            return UNSAFE.getIntVolatile(this, STATE_OFFSET);
//        }
//    }
//
//    // 模拟JVM中的SafepointSynchronize类
//    static class SafepointSynchronize {
//        // 等待进入安全点的线程数
//        static final AtomicInteger _waiting_to_block = new AtomicInteger(0);
//        // 是否需要安全点
//        static volatile boolean _need_safepoint = false;
//        // 安全点计数器，用于检测安全点状态变化
//        static volatile long _safepoint_counter = 0;
//
//        // 开始安全点操作
//        static void begin() {
//            _need_safepoint = true;
//            _safepoint_counter++; // 增加安全点计数器
//            UNSAFE.storeFence(); // 确保_need_safepoint和_safepoint_counter的更新对所有线程可见
//            // 等待所有线程进入安全点
//            while (_waiting_to_block.get() > 0) {
//                UNSAFE.loadFence(); // 确保看到_waiting_to_block的最新值
//                Thread.onSpinWait(); // 优化的自旋等待
//            }
//            System.out.println("All threads reached safepoint");
//        }
//
//        // 结束安全点操作
//        static void end() {
//            UNSAFE.storeFence(); // 确保之前的写操作都已完成
//            _need_safepoint = false;
//            _safepoint_counter++; // 再次增加安全点计数器，表示安全点结束
//        }
//
//        // 线程进入安全点
//        static void block(JavaThread thread) {
//            long local_safepoint_counter = _safepoint_counter; // 记录当前安全点计数器值
//            thread.set_thread_state(_thread_blocked);
//            _waiting_to_block.decrementAndGet();
//            // 等待安全点操作结束
//            while (_need_safepoint && local_safepoint_counter == _safepoint_counter) {
//                UNSAFE.loadFence(); // 确保看到_need_safepoint和_safepoint_counter的最新值
//                // 在实际JVM中，这里可能会使用操作系统级别的线程挂起
//                Thread.onSpinWait(); // 在演示中使用自旋等待
//            }
//            thread.set_thread_state(_thread_in_Java);
//        }
//
//        // 模拟循环回边的安全点检查
//        static void loopBackEdge(JavaThread thread) {
//            // 检查是否需要进入安全点
//            if (_need_safepoint) {
//                // 如果需要，则阻塞线程
//                block(thread);
//            }
//            // 在实际JVM中，这个检查会更加轻量级和高效
//        }
//    }
//
//    // 模拟JVM中的VMThread，负责触发STW暂停
//    static class VMThread extends Thread {
//        @Override
//        public void run() {
//            while (!isInterrupted()) {
//                try {
//                    Thread.sleep(2000); // 模拟正常执行
//                    System.out.println("Initiating STW pause");
//                    SafepointSynchronize.begin();
//
//                    // 模拟STW操作（如垃圾收集）
//                    System.out.println("Performing STW operation");
//                    Thread.sleep(1000);
//
//                    SafepointSynchronize.end();
//                    System.out.println("STW pause ended");
//                } catch (InterruptedException e) {
//                    break;
//                }
//            }
//        }
//    }
//
//    public static void main(String[] args) throws InterruptedException {
//        int numThreads = 3;
//        JavaThread[] threads = new JavaThread[numThreads];
//        SafepointSynchronize._waiting_to_block.set(numThreads);
//
//        // 创建并启动模拟的Java应用线程
//        for (int i = 0; i < numThreads; i++) {
//            final int id = i;
//            threads[i] = new JavaThread(() -> {
//                while (!Thread.currentThread().isInterrupted()) {
//                    try {
//                        // 模拟一个长时间运行的循环
//                        for (int j = 0; j < 1000000; j++) {
//                            // 在循环回边处执行安全点检查
//                            // 在实际JVM中，这个检查会由JIT编译器自动插入
//                            if (j % 10000 == 0) {
//                                SafepointSynchronize.loopBackEdge((JavaThread) Thread.currentThread());
//                            }
//                        }
//                        Thread.sleep(100); // 模拟其他工作
//                    } catch (InterruptedException e) {
//                        break;
//                    }
//                }
//            });
//            threads[i].start();
//        }
//
//        // 创建并启动VMThread
//        VMThread vmThread = new VMThread();
//        vmThread.start();
//
//        // 让模拟运行10秒
//        Thread.sleep(10000);
//
//        // 清理：中断并等待所有线程结束
//        vmThread.interrupt();
//        for (JavaThread thread : threads) {
//            thread.interrupt();
//        }
//
//        vmThread.join();
//        for (JavaThread thread : threads) {
//            thread.join();
//        }
//    }
//}